import { Socket, sys } from "cc";
// import axios from "../utils/axios.min.js";
import { storage } from "../utils/storage"
import { userStore } from "./user"
import { base_url } from "./config"
import { useSocket } from "./socket";

export default function request(options: any = {}) {
    if (!options.params) options.params = {};

    let ns = base_url + '/app';

    // 处理地址
    if (options.proxy === undefined || options.proxy) {
        options.url = ns + options.url;
    }

    // 处理参数
    options.data =
        options.method?.toLocaleUpperCase() == "POST" ? options.data : options.params;

    return service(options);
}
// 请求队列
let requests: any[] = [];
// 忽略
let ignore = {
    token: ['refreshToken'],
}
// Token 是否刷新中
let isRefreshing = false;
let service
// 封装网络请求
if (sys.platform.includes('WECHAT')) {
    const wx = window['wx']
    service = function (options: any) {
        // 缓存信息
        const socket = useSocket()
        // 标识
        let Authorization = userStore().token || "";
        // 忽略标识
        ignore.token.forEach((e) => {
            if (options.url.includes(e)) {
                Authorization = "";
            }
        });
        console.log(`[${options.method || "GET"}] ${options.url}`);
        return new Promise(async (resolve, reject) => {
            // 继续请求
            function next() {
                wx.request({
                    ...options,

                    header: {
                        Authorization,
                        ...options.header,
                    },

                    success(res) {
                        const { code, data, message } = res.data as {
                            code: number;
                            message: string;
                            data: any;
                        };

                        // 无权限
                        if (res.statusCode === 401) {
                            userStore().logout();
                            socket.disconnect()
                            return reject({ message });
                        }

                        // 服务异常
                        if (res.statusCode === 502) {
                            return reject({
                                message: "服务异常",
                            });
                        }

                        // 未找到
                        if (res.statusCode === 404) {
                            return reject({
                                message: `[404] ${options.url}`,
                            });
                        }

                        // 成功
                        if (res.statusCode === 200) {
                            switch (code) {
                                case 1000:
                                    resolve(data);
                                    break;
                                default:
                                    reject({ message, code });
                            }
                        }
                    },

                    fail(err) {
                        reject({ message: err.errMsg });
                    },
                });
            }

            // 刷新token处理
            if (!options.url.includes("refreshToken")) {
                if (Authorization) {
                    // 判断 token 是否过期
                    console.log(storage.isExpired("token"))
                    if (storage.isExpired("token")) {
                        // 判断 refreshToken 是否过期
                        if (storage.isExpired("refreshToken")) {
                            console.log("refreshToken过期")
                            // 退出登录
                            return userStore().logout();
                        }

                        // 是否在刷新中
                        if (!isRefreshing) {
                            isRefreshing = true;
                            userStore().refreshToken()
                                .then((token) => {
                                    console.log("刷新token成功",token)
                                    requests.forEach((cb) => cb(token));
                                    requests = [];
                                    isRefreshing = false;
                                })
                                .catch((err) => {
                                    console.log("刷新token失败")
                                    isRefreshing = false;
                                    reject(err);
                                });
                        }
                        return new Promise((resolve) => {
                            // 继续请求
                            requests.push((token: string) => {
                                console.log("新token重新请求",token)
                                // 重新设置 token
                                Authorization = token;
                                next();
                                resolve();
                            });
                        });
                    }
                }
            }

            next();
        });
    }
} else if (sys.platform == 'BYTEDANCE_MINI_GAME') {

} else {

    // service = axios.create({
    //     timeout: 30000,
    //     withCredentials: false
    // });
    // // 请求
    // service.interceptors.request.use(
    //     (req: any) => {
    //         const user = userStore();
    //         // 标识
    //         let Authorization = user.token || "";
    //         // 忽略标识
    //         ignore.token.forEach((e) => {
    //             if (req.url.includes(e)) {
    //                 Authorization = "";
    //             }
    //         });
    //         // 验证 token
    //         // 请求标识
    //         if (req.headers && req.headers['Authorization'] !== null) {
    //             req.headers['Authorization'] = user.token;
    //         }
    //         // 判断 token 是否过期
    //         if (Authorization) {
    //             if (storage.isExpired('token')) {
    //                 // 判断 refreshToken 是否过期
    //                 if (storage.isExpired('refreshToken')) {
    //                     console.log('登录状态已失效，请重新登录')
    //                     // ElMessage.error('登录状态已失效，请重新登录');
    //                     user.logout();
    //                 } else {
    //                     // 是否在刷新中
    //                     if (!isRefreshing) {
    //                         isRefreshing = true;

    //                         user.refreshToken()
    //                             .then(token => {
    //                                 console.log("刷新了token")
    //                                 requests.forEach(cb => cb(token));
    //                                 requests = [];
    //                                 isRefreshing = false;
    //                             })
    //                             .catch(() => {
    //                                 user.logout();
    //                             });
    //                     }

    //                     return new Promise(resolve => {
    //                         // 继续请求
    //                         requests.push(token => {
    //                             // 重新设置 token
    //                             if (req.headers) {
    //                                 req.headers['Authorization'] = token;
    //                             }
    //                             resolve(req);
    //                         });
    //                     });
    //                 }
    //             }
    //         }
    //         return req;
    //     },
    //     error => {
    //         console.log(error, "error")
    //         return Promise.reject(error);
    //     }
    // );

    // // 响应
    // service.interceptors.response.use(
    //     res => {

    //         if (!res?.data) {
    //             return res;
    //         }

    //         const { code, data, message } = res.data;

    //         if (!code) {
    //             return res.data;
    //         }

    //         switch (code) {
    //             case 1000:
    //                 return data;
    //             default:
    //                 return Promise.reject({ code, message });
    //         }
    //     },
    //     async error => {
    //         const socket = useSocket()
    //         if (error.response) {
    //             const { status } = error.response;
    //             const user = userStore();
    //             if (status == 401) {
    //                 user.logout();
    //                 socket.disconnect()
    //             }
    //         }

    //         return Promise.reject({ message: error.message });
    //     }
    // );
}

